# 1 "gdt.c"
# 1 "/home/diego/sodium/kernel//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "gdt.c"
# 1 "../include/kernel/gdt.h" 1






# 1 "../include/kernel/definiciones.h" 1
# 14 "../include/kernel/definiciones.h"
# 1 "../include/usr/tipos.h" 1
# 15 "../include/usr/tipos.h"
typedef unsigned int dword;
typedef unsigned short word;
typedef unsigned char byte;

typedef unsigned char u8;
typedef signed char s8;
typedef unsigned short u16;
typedef signed short s16;
typedef unsigned int u32;
typedef signed int s32;


typedef struct _u80 { unsigned int word[20]; } u80;
# 15 "../include/kernel/definiciones.h" 2
# 62 "../include/kernel/definiciones.h"
char stArgAux[128];
# 8 "../include/kernel/gdt.h" 2
# 1 "../include/kernel/pcb.h" 1







# 1 "../include/kernel/shm.h" 1
# 18 "../include/kernel/shm.h"
typedef unsigned int size_t;
typedef int key_t;
typedef int bool;


typedef struct _stuMemoriasAtachadas_
{
 bool utilizada;
 int posicionEnShMem;
 int posicionEnAttach;
}stuMemoriasAtachadas;


typedef struct _attach_
{
 int pid;
 void * ptrShAddr;

}attach;


typedef struct _shMem_
{
 key_t key;
 unsigned long int tamanio;
 attach procAtt[5];
 bool declarada;
}shMem;

shMem memoriasCompartidas[5];




int iFnShmGet(key_t key, size_t size);


int iFnShmAt(int shmid, void * shmAddr);


int iFnShmDt(int shmid);

int iFnShmDtProc(int shmid, unsigned int uiPid);
int iFnShmDtAllProc(unsigned int uiPid);

unsigned long ulFnMaxDirShmProc(unsigned int uiPid);

void vFnInicializarShms();
void vFnVerShm();




void vFnCopiarVariablesCompartidas();



void vFnCopiarVariable(void * dest, void * src, size_t tamanio);
# 9 "../include/kernel/pcb.h" 2
# 1 "../include/kernel/tiempo.h" 1
# 53 "../include/kernel/tiempo.h"
typedef unsigned long int time_t;
typedef unsigned long int clock_t;





typedef struct{

        clock_t tms_utime;


        clock_t tms_stime;


        clock_t tms_cutime;


        clock_t tms_cstime;
} tms;





typedef struct{

        int tz_minuteswest;


        int tz_dsttime;
} timezone;





typedef struct{

        unsigned long int tv_sec;


        unsigned long int tv_usec;
} timeval;





typedef struct{

        timeval it_interval;


        timeval it_value;
} itimerval;





typedef struct{

        int modes;


 long offset;


 long freq;


 long maxerror;


 long esterror;


 int status;


 long constant;


 long precision;


 long tolerance;


 timeval time;


 long tick;
} timex;





typedef struct{

        long int tv_sec;


        long int tv_nsec;
} timespec;
# 10 "../include/kernel/pcb.h" 2
# 27 "../include/kernel/pcb.h"
typedef struct {
 unsigned char ident[16];
 unsigned short type;
 unsigned short machine;
 unsigned int version;
 unsigned int entry;
 unsigned int phoff;
 unsigned int sphoff;
 unsigned int flags;
 unsigned short ehsize;
 unsigned short phentsize;
 unsigned short phnum;
 unsigned short shentsize;
 unsigned short shnum;
 unsigned short shstrndx;
} elfHeader;

typedef struct {
 unsigned int name;
 unsigned int type;
 unsigned int flags;
 unsigned int addr;
 unsigned int offset;
 unsigned int size;
 unsigned int link;
 unsigned int info;
 unsigned int addralign;
 unsigned int entsize;
}SHeader;

typedef struct {
        unsigned int type;
 unsigned int offset;
 unsigned int vaddr;
        unsigned int paddr;
        unsigned int filesz;
        unsigned int memsz;
        unsigned int flags;
        unsigned int align;
} PHeader;






typedef struct {
   elfHeader elfHeaderData;
   SHeader SHeaderData;
   PHeader PHeaderData;
   unsigned char ucbuffer[4];
} stuHeaderELF;





typedef struct {
   int iEstado;
   long int liTamanio;
} stuEsperarMemoria;
# 96 "../include/kernel/pcb.h"
typedef struct _stuPCB_{
  unsigned long int ulId;
  unsigned int uiIndiceGDT_CS;
  unsigned int uiIndiceGDT_DS;
  unsigned int uiIndiceGDT_TSS;
  unsigned int uiIndiceGDT_SS0;
  void (* vFnFuncion) ();

  unsigned long ulParentId;
  unsigned long ulUsuarioId;
  int iPrioridad;
  int iEstado;
  unsigned long lNHijos;
  int iExitStatus;
  unsigned long ulLugarTSS;
  char stNombre[25];
  unsigned int uiTamProc;
  struct stuTablaPagina * pstuTablaPaginacion;
  unsigned int uiDirBase,

        uiLimite;
  stuMemoriasAtachadas memoriasAtachadas[5];


  unsigned long ulTiempoEspera;
  unsigned long ulTiempoServicio;



  struct stuPCB* pstuPcbSiguiente;

  tms stuTmsTiemposProceso;

  itimerval timers[3];

  long lNanosleep;

  unsigned int *puRestoDelNanosleep;

    long lPidTracer;

    unsigned int uiTamanioTexto;
    unsigned int uiTamanioDatosInicializados;
    unsigned int uiTamanioStack;

    unsigned int uiTamanioOverhead;

    unsigned int uiEsperaTeclado;

    stuHeaderELF stuCabeceraELF;
    int iModoParticion;
    stuEsperarMemoria stuEsperaMemoria;
    unsigned int uiBaseSs0;
}stuPCB;
# 9 "../include/kernel/gdt.h" 2
# 32 "../include/kernel/gdt.h"
stuPCB pstuPCB[50];

int iCOLA_FLOPPY_ES[50];

unsigned int uiCOLA_FLOPPY_ES_INDEX_INI;
unsigned int uiCOLA_FLOPPY_ES_INDEX_FIN;
unsigned int uiPROC_FLOPPY;
unsigned int uiFIN_FLOPPY;
unsigned int uiCiclo;

unsigned int uiTamHeap;
# 63 "../include/kernel/gdt.h"
typedef struct {
  unsigned short usLimiteBajo;
  unsigned short usBaseBajo;
  unsigned char ucBaseMedio;







 unsigned char ucAcesso;

  unsigned int bitLimiteAlto:4;
# 89 "../include/kernel/gdt.h"
 unsigned int bitGranularidad:4;

  unsigned char usBaseAlto;

} __attribute__((packed)) stuGDTDescriptor;






typedef struct {
   stuGDTDescriptor stuGdtDescriptorDescs[8192];
} stuEstructuraGdt;



stuEstructuraGdt *pstuTablaGdt;






typedef struct {
  unsigned int control;
  unsigned int status;
  unsigned int tag;
  unsigned int ip;
  unsigned int cs;
  unsigned int dp;
  unsigned int ds;
  u80 st[8];
} __attribute__((packed)) stuFpu;
# 131 "../include/kernel/gdt.h"
typedef struct {
  unsigned int uiEnlace;
  unsigned int esp0;
  unsigned int ss0;
  unsigned int esp1;
  unsigned int ss1;
  unsigned int esp2;
  unsigned int ss2;
  unsigned int cr3;
  unsigned int eip;
  unsigned int uiEBandera;
  unsigned int eax;
  unsigned int ecx;
  unsigned int edx;
  unsigned int ebx;
  unsigned int esp;
  unsigned int ebp;
  unsigned int esi;
  unsigned int edi;
  unsigned int es;
  unsigned int cs;
  unsigned int ss;
  unsigned int ds;
  unsigned int fs;
  unsigned int gs;
  unsigned int ldt;
  unsigned int trapbit;
  unsigned int uIOMapeoBase;
  char espacio0[1024];
  char espacio1[16];
  char espacio2[16];
  stuFpu fpu;
}stuTSS;


typedef struct {
    void * pvPuntoCarga;
    unsigned int uiTamanioTexto;
    unsigned int uiTamanioDatosInicializados;
    unsigned int uiTamanioStack;
    char stNombre [13];
} stuInfoEjecutable;







stuPCB pstuPCB[50];
stuTSS stuTSSTablaTareas[50];





typedef struct {
   char stBinario[30];
   long int liTamanio;
} stuListaEspera;


int iCantEnEspera;
stuListaEspera stListaEspera[100];
void vFnGdtInicializar(dword);

int iFnBuscaPosicionProc(unsigned long);
unsigned int uiFnSetearBaseLimiteDescriptor(int,unsigned int,unsigned int);

unsigned int iFnAgregarDescriptorGDT(unsigned int,unsigned int,unsigned int,int);

int iFnBuscarPCBLibre();
unsigned int uiFnBuscarEntradaGDTLibre();

void vFnRecorrerListaEspera();
int iFnCrearTSSReloj (void*,int,unsigned int,unsigned int,unsigned int);
int iFnCrearTSS (void*,void*,int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,int);

int iFnCrearPCB(int,void*,char*,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int, unsigned int, unsigned int,unsigned int);

int iFnInstanciarReloj(void *, char*);
int iFnInstanciarIdle();
int iFnInstanciarInit();

void vFnAgregarListaEspera(char*, long int);

int iFnLeerCabeceraEjecutable(char* stArchivo, stuInfoEjecutable* pstuInfo);

int iFnCrearProceso(char *,int,int);
int iFnCrearCallGate(int, unsigned short, unsigned short, unsigned char, unsigned int, unsigned int, unsigned short);
int iFnRedimensionarProceso(unsigned long ulPid, unsigned long ulBrk);

int iFnDuplicarProceso(unsigned int uiProcPadre);
int iFnEliminarProceso(unsigned int uiProcesp);
int iFnReemplazarProcesoFija( unsigned int uiProceso, unsigned char *__codigo, unsigned int size );
int iFnReemplazarProceso(unsigned long, char *, unsigned int);






char* pstFnObtenerEnviroment();


int iFnClonarProceso();
# 2 "gdt.c" 2

# 1 "../include/video.h" 1
# 14 "../include/video.h"
# 1 "../include/kernel/libk/string.h" 1
# 9 "../include/kernel/libk/string.h"
inline unsigned char* ucpFnCopiarMemoria(unsigned char *ucpDestino,
      unsigned char *ucpOrigen,
      unsigned int uiTamanio);
inline unsigned char* ucpFnMemSetCero(unsigned char *ucpDirInicio,
                  unsigned int uiTamanio );

int iFnLongitudCadena (const char *cnstCadena);
int iFnCompararCadenas (const char *, const char *);
int iFnCompararCadenas2 (const char *, const char *);
int iFnCopiaCaracter (char *, const char *);
int iFnCopiaCadena (char *, const char *);

int iFnCopiaEntero (char *, const int);
int iFnCopiaFloat (char *, const float, const int);
int iFnCopiaWord (char *, const word);
int iFnCopiaByte (char *, const byte);
int iFnCopiaHexa (char *, const int);
int iFnCopiaWordHexa (char *, const word);
int iFnCopiaByteHexa (char *, const byte);
void vFnImprimirString (char *, const char *, ...);
int iFnLongitudCadena (const char *);

int iFnCopiaCadena2 (char *, const char *);
char * pstFnConcatenarCadena (char * , char * );
int iFnBuscarEnCadena (char * , char * ,int );
char * pstFnCadenaIzquierda (char * , int );
char * pstFnCadenaDerecha (char * , int );
int iFnEsNumero (char * stCadena);

void vFnStrLwr (char * stCadena);
void vFnStrUpr (char * stCadena);
# 15 "../include/video.h" 2
# 58 "../include/video.h"
typedef char* va_list;
# 100 "../include/video.h"
int iFnImprimirCadenas (int,const char*);




void vFnImprimirEntero (int,const int);




void vFnImprimirFloat (int,const double, const int);




void vFnImprimirHexa (int,const int);




void vFnImprimirWordHexa (int,const word);




void vFnImprimirByteHexa (int,const byte);





void vFnImprimirWin (int,const char*, ... );
void vFnImprimir (const char*, ... );
void vFnImprimirI (const char*, ... );

extern char cFnSysObtenerColor(int);
extern void vFnSysSetearColor(int,char);
extern void vFnSysSetearX(int,int);
extern void vFnSysSetearY(int,int);
extern void vFnClsWin(int);





void vFnImprimirContextSwitch(int color,int pid, char* nombre, int indiceGDT);
void vFnImprimirPrompt();
void vFnImprimirOk(int linea);
void vFnImprimirNOk(int linea);

void vFnImprimirVentana (int hVentana, const char *cnstCadena, ...);






int bTerminalActiva;

void vFnCambiarTerminal(void);
void vFnLog (const char *cnstCadena, ...);

void vFnLogScrollArriba();
void vFnLogScrollAbajo();

void vFnLogScrollMaximo();
void vFnLogScrollMinimo();
void vFnLogBorrar();
# 4 "gdt.c" 2
# 1 "../include/kernel/registros.h" 1
# 15 "../include/kernel/registros.h"
word wFnGetSS();




word wFnGetES();




word wFnGetCS();




word wFnGetDS();




word wFnGetFS();




word wFnGetGS();




dword wFnGetESP();

void vFnLTR(dword);

dword uivFnSTR();
# 5 "gdt.c" 2
# 1 "../include/kernel/idle.h" 1







unsigned int __idle_size();
unsigned char *__idle_begin();
# 6 "gdt.c" 2
# 1 "../include/kernel/sched.h" 1
# 15 "../include/kernel/sched.h"
typedef struct
{
 int sched_priority;
}sched_param;


unsigned long int uliTimeSlice;


unsigned long int uliQuantum;

unsigned long int uliBTSQ;


static int staiN = 0;

static int staiProcesoAnterior = -1;


int iTareaNula;

void vFnPlanificadorFIFO();
void vFnPlanificadorRR();
void vFnPlanificadorBTS();
# 7 "gdt.c" 2
# 1 "../include/kernel/syscall.h" 1







# 1 "../include/kernel/signal.h" 1
# 9 "../include/kernel/syscall.h" 2
# 1 "../include/kernel/semaforo.h" 1
# 20 "../include/kernel/semaforo.h"
typedef struct
{
 int inicializado;
 int valor;
 unsigned long int head;
 unsigned long int tail;

 unsigned long int procesosEnCola;

 unsigned long int cola[5];
 unsigned long int pshared;
}semaforo;





typedef struct
{
 int sem_id;
}sem_t;





typedef struct{
 int pshared;
 unsigned int value;
} sem_init_params;


void vFnEncolarProceso(semaforo *sem, unsigned long int uliId);


void vFnInicializaCola(unsigned long int *cola);


int iFnHayProcesoEnEspera(semaforo *sem);


unsigned long int uliFnDesencolarProceso(semaforo *sem);


void vFnInicializarSemaforos();
# 77 "../include/kernel/semaforo.h"
int iFnSemInit(sem_t *sem, int pshared, unsigned int value);
# 86 "../include/kernel/semaforo.h"
int iFnSemClose(sem_t *sem);
# 106 "../include/kernel/semaforo.h"
int iFnSemWait(sem_t *sem);
# 116 "../include/kernel/semaforo.h"
int iFnSemPost(sem_t *sem);

int validaExistenciaSemaforo(sem_t *sem);


int agregarSemaforoAlSistema(int pshared, unsigned int value);

void vFnVerSemaforos();
# 10 "../include/kernel/syscall.h" 2
# 195 "../include/kernel/syscall.h"
enum __ptrace_request {
 PTRACE_TRACEME,
 PTRACE_PEEKTEXT,
 PTRACE_PEEKDATA,
 PTRACE_PEEKUSER,
 PTRACE_POKETEXT,
 PTRACE_POKEDATA,
 PTRACE_POKEUSER,
 PTRACE_GETREGS,
 PTRACE_GETFPREGS,
 PTRACE_SETREGS,
 PTRACE_SETFPREGS,
 PTRACE_CONT,
 PTRACE_KILL,
 PTRACE_ATTACH,
 PTRACE_DETACH
};


typedef struct {
 int iPid;
 void *pvAddr;
 void *pvData;
}__ptrace_param;



typedef struct _stuRegs_
{
  long ebx;
  long ecx;
  long edx;
  long esi;
  long edi;
  long ebp;
  long eax;
  int xds;
  int xes;
  long orig_eax;
  long eip;
  int xcs;
  long eflags;
  long esp;
  int xss;
} stuRegs;






long lFnSysExit( int status );
long lFnSysFork();
long lFnSysTest( long num );
long lFnSysRead( int, void *buf, size_t count );
long lFnSysWrite( int, const void *buf, size_t count );
long lFnSysWaitPid( int pid, int *status, int options );
long lFnSysExecve( const char *filename, char *argv[], char *envp[] );
long lFnSysTime( long *t );
long lFnSysGetPid();
long lFnSysKill( int pid, int sig );
long lFnSysGetPPid();
long lFnSysReboot( int flag );
long lFnSysSodiumCallgate(int iOpcion, int iPar1, int iPar2);
long lFnSysBrk(unsigned long);
long lFnSysSBrk(unsigned long);
long lFnSysSemInit( sem_t *sem, sem_init_params * params);
long lFnSysSemPost( sem_t *sem );
long lFnSysSemWait( sem_t *sem );
long lFnSysSemClose( sem_t *sem );
long lFnSysShmGet( key_t key, size_t size );
long lFnSysShmAt( int shmid, void * shmAddr );
long lFnSysShmDt( key_t key );

int iFnSysSumar(int a, int b, int * res);



long lFnSysNice( int );
long lFnSysGetpriority( int, int );
long lFnSysSetpriority( int, int, int );
long lFnSysClone(stuRegs *,int flags);


long lFnSysIdle();



long lFnSysSchedSetParam(int p);
long lFnSysSchedGetParam();
long lFnSysSchedSetScheduler(int p);
long lFnSysSchedGetScheduler();
long lFnSysSchedYield();
long lFnSysSchedGetPriorityMax();
long lFnSysSchedGetPriorityMin();
long lFnSysSchedRrGetInterval();





long lFnSysStime(time_t *newtime);
long lFnSysTimes(tms *ptmsbuffer);
long lFnSysGettimeofday(timeval *ptimervalTp, timezone *ptimezoneTzp);
long lFnSysSettimeofday(timeval *ptimevalTp, timezone *ptimezoneTzp);
long lFnSysGettimer(int iWhich, itimerval *pitimervalValue);
long lFnSysSettimer(int iWhich, itimerval const *pcnitimervalValue, itimerval *ptimervalOvalue);
long lFnSysAdjtimex(timex *ptimexBuffer);
long lFnSysNanosleep(timespec const *pcntimespecRequested_time, timespec *ptimespecRemaining);



long lFnSysPtrace( int request, void *pvDirParam );





unsigned long ulFnSysBrk(unsigned long brk);
# 8 "gdt.c" 2



# 1 "../include/fs/ramfs.h" 1
# 30 "../include/fs/ramfs.h"
typedef struct {
 char strNombreArchivo[11];
 word wSeg;
 word wOff;
 dword dwTamanio;
} __attribute__((packed)) stEntradaLS;




typedef struct {
 stEntradaLS stEnt[20];
} __attribute__((packed)) stDirectorio;




typedef struct {
 char strEtiqueta[20];
 char strPMontaje[44];
 dword dwDireccionInicial;
 dword dwTamanio;
 stDirectorio *pstDirRaiz;
 dword dwEntradasRaiz;
 u8 bActivo;
} stDiscoRAM;

int iFnRamFsInit(void);

int iFnNormalizarNomArch(const char *strNomArch83, char *strNomArch);

int iFnBuscarArchivo(stDirectorio * pstDir, char *strNombreArchivo, stEntradaLS ** ppstEntradaLSArchEnc);

int iFnObtenerDirectorio(char *strPMontaje, stDirectorio ** ppstDir);

int iFnObtenerDisco(char *strPMontaje, stDiscoRAM **ppstDisco);

int iFnRamFsLs(char *strParams);
# 12 "gdt.c" 2

# 1 "../include/kernel/mem/mem_part_kernel.h" 1



void* ptrHeapBajoKernel;
long int liTamanioHeapBajoKernel;

void* ptrHeapAltoUsuario;
long int liTamanioHeapAltoUsuario;


long int liTamFijaMemBaja;
long int liTamFijaMemAlta;
long int liTamanioSolicitado;

int iModoMemoriaKernel;
char stTamanioMemFija[20];
int iTamanioMemFijaSeteado;
int iPosicionSetMemFija;
int iContinuar;
int iModoFijoUser;

void vFnInicializarHeapsKernel();
void vFnConfigurarParticiones();

void * pvFnReservarParticionUsuario(unsigned int);
void * pvFnReservarParticionKernel(unsigned int);
void * pvFnRedimensionarSegmento(void*, unsigned long);
void vFnLiberarParticion( void * );
unsigned int uiHeapKernelInicializado;
unsigned int uiKernelStack;
# 14 "gdt.c" 2
# 28 "gdt.c"
extern dword pdwGDT;
extern stuPCB pstuPCB[50];
extern stuTSS stuTSSTablaTareas[50];



iCantEnEspera = 0;

unsigned int uiUltimoPid = 0;
unsigned long ulProcActual = 0;
unsigned long ulUltimoProcesoEnFPU = 0;

unsigned char ucLecturaTemporalELF[0x80];



unsigned char iMapaGDT[ (sizeof(stuEstructuraGdt) / sizeof(stuGDTDescriptor)) / 8 ];


unsigned char iMapaSegmentos[ (16 * 0x100000 / 0x20000) / 8 ];
# 78 "gdt.c"
void
vFnGdtInicializar (dword pdwGDT)
{
  int iN;
  pstuTablaGdt = (stuEstructuraGdt *) pdwGDT;


  for( iN = 0; iN < sizeof( iMapaGDT ) / sizeof( iMapaGDT[0]); iN++ )
   iMapaGDT[iN] = 0;

  do{ if( 1 ){ iMapaGDT[ (0 -(0%8)) / 8 ] |= (1 << (7-((0)%8))); } else { iMapaGDT[ (0 -(0%8)) / 8 ] &= ~(1 << (7-((0)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (1 -(1%8)) / 8 ] |= (1 << (7-((1)%8))); } else { iMapaGDT[ (1 -(1%8)) / 8 ] &= ~(1 << (7-((1)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (2 -(2%8)) / 8 ] |= (1 << (7-((2)%8))); } else { iMapaGDT[ (2 -(2%8)) / 8 ] &= ~(1 << (7-((2)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (3 -(3%8)) / 8 ] |= (1 << (7-((3)%8))); } else { iMapaGDT[ (3 -(3%8)) / 8 ] &= ~(1 << (7-((3)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (4 -(4%8)) / 8 ] |= (1 << (7-((4)%8))); } else { iMapaGDT[ (4 -(4%8)) / 8 ] &= ~(1 << (7-((4)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (5 -(5%8)) / 8 ] |= (1 << (7-((5)%8))); } else { iMapaGDT[ (5 -(5%8)) / 8 ] &= ~(1 << (7-((5)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (6 -(6%8)) / 8 ] |= (1 << (7-((6)%8))); } else { iMapaGDT[ (6 -(6%8)) / 8 ] &= ~(1 << (7-((6)%8))); } }while( 0 );
  do{ if( 1 ){ iMapaGDT[ (7 -(7%8)) / 8 ] |= (1 << (7-((7)%8))); } else { iMapaGDT[ (7 -(7%8)) / 8 ] &= ~(1 << (7-((7)%8))); } }while( 0 );



  for (iN = 0; iN < 50; iN++)
    {
      pstuPCB[iN].iEstado = -1;
    }






}
# 118 "gdt.c"
int iFnBuscaPosicionProc (unsigned long ulPid) {
    int iN = 0;

    while (iN < 50) {
        if( (pstuPCB[iN].ulId == ulPid) &&
            (pstuPCB[iN].iEstado != -1) &&
            (pstuPCB[iN].iEstado != 4) ) {
                return iN;
        }
        iN++;
    }

    return -1;
}
# 141 "gdt.c"
unsigned int
uiFnSetearBaseLimiteDescriptor( int uiPosicion,
    unsigned int uiBase,
    unsigned int uiLimite )
{
 pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].usBaseBajo = uiBase & 0xFFFF;
 pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].ucBaseMedio = (uiBase >> 16) & 0xFF;
 pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].usBaseAlto = uiBase >> 24;
 pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].usLimiteBajo = uiLimite & 0xFFFF;
 pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].bitLimiteAlto = (uiLimite >> 16) & 0x0F;

 return uiPosicion;
}
# 164 "gdt.c"
unsigned int
uiFnAgregarDescriptorGDT (unsigned int uiBase, unsigned int uiLimite,
     unsigned int uiOpt, int uiPosicion)
{
  uiFnSetearBaseLimiteDescriptor( uiPosicion, uiBase, uiLimite );

  pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].ucAcesso = (uiOpt + 0x8000) >> 8;
  pstuTablaGdt->stuGdtDescriptorDescs[uiPosicion].bitGranularidad = ((uiOpt & 0xff) >> 4);

  return (uiPosicion);
}
# 184 "gdt.c"
int iFnBuscarPCBLibre()
{
  int iPosicion = 0;

    while ( iPosicion < 50 ) {
        if (pstuPCB[iPosicion].iEstado == 4 ||
            pstuPCB[iPosicion].iEstado == -1 ) {
                return iPosicion;
        }
        iPosicion++;
    }

    return -1;
}







unsigned int uiFnBuscarEntradaGDTLibre()
{
  unsigned int uiPosicion = 0;

    while ( uiPosicion < (sizeof(stuEstructuraGdt) / sizeof(stuGDTDescriptor)) ) {
        if ( !(iMapaGDT[ (uiPosicion) / 8 ] & (1 << (7-((uiPosicion)%8)))) ) {
            do{ if( 1 ){ iMapaGDT[ (uiPosicion-(uiPosicion%8)) / 8 ] |= (1 << (7-((uiPosicion)%8))); } else { iMapaGDT[ (uiPosicion-(uiPosicion%8)) / 8 ] &= ~(1 << (7-((uiPosicion)%8))); } }while( 0 );
            return uiPosicion;
        }
        uiPosicion++;
    }
  return 0;
}






unsigned int uiFnBuscarSegmentoLibre()
{
  unsigned int uiPosicion = 0;

  while (uiPosicion < (16 * 0x100000 / 0x20000) && (iMapaSegmentos[ (uiPosicion) / 8 ] & (1 << (7-((uiPosicion)%8)))) )
    {
      uiPosicion++;
    }

  if (uiPosicion < (16 * 0x100000 / 0x20000) ){
   do{ if( 1 ){ iMapaSegmentos[ (uiPosicion-(uiPosicion%8)) / 8 ] |= (1 << (7-((uiPosicion)%8))); } else { iMapaSegmentos[ (uiPosicion-(uiPosicion%8)) / 8 ] &= ~(1 << (7-((uiPosicion)%8))); } }while( 0 );
   return uiPosicion;
  }

  return 0;
}
# 252 "gdt.c"
int
iFnCrearTSSReloj (void *pEIP,
        int iPosicion,
        unsigned int uiCS,
        unsigned int uiDS,
        unsigned int uiSS)
{
    int iN = 0;

    stuTSSTablaTareas[iPosicion].trapbit = 0;
    stuTSSTablaTareas[iPosicion].uIOMapeoBase = sizeof (stuTSS);
    stuTSSTablaTareas[iPosicion].cs = uiCS;

    stuTSSTablaTareas[iPosicion].fs = uiDS;
    stuTSSTablaTareas[iPosicion].gs = uiDS;
    stuTSSTablaTareas[iPosicion].ds = uiDS;
    stuTSSTablaTareas[iPosicion].es = uiDS;
    stuTSSTablaTareas[iPosicion].ss = uiSS;

    stuTSSTablaTareas[iPosicion].ss0 = uiSS;
    stuTSSTablaTareas[iPosicion].ss1 = uiSS;
    stuTSSTablaTareas[iPosicion].ss2 = uiSS;

    stuTSSTablaTareas[iPosicion].esp0 =
        (unsigned int) &stuTSSTablaTareas[iPosicion].
        espacio0[4096 - 8];

    stuTSSTablaTareas[iPosicion].esp1 =
        (unsigned int) &stuTSSTablaTareas[iPosicion].
        espacio1[16 - 8];

    stuTSSTablaTareas[iPosicion].esp2 =
        (unsigned int) &stuTSSTablaTareas[iPosicion].
        espacio2[16 - 8];

    stuTSSTablaTareas[iPosicion].esp =
        (unsigned int) &stuTSSTablaTareas[iPosicion].
        espacio0[4096 - 8];

    stuTSSTablaTareas[iPosicion].ebp =
        (unsigned int) &stuTSSTablaTareas[iPosicion].
        espacio0[4096 - 8];




    for (iN = 0; iN < 4096; iN++) {
        stuTSSTablaTareas[iPosicion].espacio0[iN] = 0x11L;
    }
    for (iN = 0; iN < 16; iN++) {
        stuTSSTablaTareas[iPosicion].espacio1[iN] = 0x22L;
    }
    for (iN = 0; iN < 16; iN++) {
        stuTSSTablaTareas[iPosicion].espacio2[iN] = 0x33L;
    }


    stuTSSTablaTareas[iPosicion].uiEBandera = 0x202L;

    stuTSSTablaTareas[iPosicion].eip = (unsigned int) pEIP;
    stuTSSTablaTareas[iPosicion].ldt = 0;
    stuTSSTablaTareas[iPosicion].eax = 0;
    stuTSSTablaTareas[iPosicion].ebx = 0;
    stuTSSTablaTareas[iPosicion].ecx = 0;
    stuTSSTablaTareas[iPosicion].edx = 0;





    stuTSSTablaTareas[iPosicion].fpu.control = 0x0360;
    stuTSSTablaTareas[iPosicion].fpu.status = 0x0000;
    stuTSSTablaTareas[iPosicion].fpu.tag = 0xFFFF;






    return (iPosicion);
}
# 350 "gdt.c"
int iFnCrearTSS (void *pEIP,
       void *pESP,
      int iPosicion,
      unsigned int uiStackOffset,
      unsigned int uiCS,
      unsigned int uiDS,
      unsigned int uiSS,
      unsigned int uiSS0,
         int iPrivilegio)
{
        if (iPrivilegio == 3)
          {
           uiCS |= 0x3;
           uiDS |= 0x3;
    uiSS |= 0x3;
          }
        if (iPrivilegio == 2)
          {
           uiCS |= 0x2;
           uiDS |= 0x2;
    uiSS |= 0x2;
          }
        if (iPrivilegio == 1)
          {
           uiCS |= 0x1;
           uiDS |= 0x1;
    uiSS |= 0x1;
          }

 stuTSSTablaTareas[iPosicion].trapbit = 0;
 stuTSSTablaTareas[iPosicion].uIOMapeoBase = sizeof (stuTSS);
 stuTSSTablaTareas[iPosicion].cs = uiCS;
 stuTSSTablaTareas[iPosicion].fs = uiDS;
 stuTSSTablaTareas[iPosicion].gs = uiDS;
 stuTSSTablaTareas[iPosicion].ds = uiDS;
 stuTSSTablaTareas[iPosicion].es = uiDS;
 stuTSSTablaTareas[iPosicion].ss = uiSS;







    stuTSSTablaTareas[iPosicion].ss0 = uiSS0;
 stuTSSTablaTareas[iPosicion].ss1 = 0x21;
 stuTSSTablaTareas[iPosicion].ss2 = 0x2A;

    stuTSSTablaTareas[iPosicion].esp0 = (void*)(4096 - 0x1);
    stuTSSTablaTareas[iPosicion].esp1 = (void*)(4096 - 0x1);
    stuTSSTablaTareas[iPosicion].esp2 = (void*)(4096 - 0x1);

 stuTSSTablaTareas[iPosicion].esp = (unsigned int) (pESP - uiStackOffset);
 stuTSSTablaTareas[iPosicion].ebp = (unsigned int) (pESP - uiStackOffset);

 stuTSSTablaTareas[iPosicion].uiEBandera = 0x3202L;

 stuTSSTablaTareas[iPosicion].eip = (unsigned int) pEIP;
 stuTSSTablaTareas[iPosicion].ldt = 0;
 stuTSSTablaTareas[iPosicion].eax = 0;
 stuTSSTablaTareas[iPosicion].ebx = 0;
 stuTSSTablaTareas[iPosicion].ecx = 0;
 stuTSSTablaTareas[iPosicion].edx = 0;




 stuTSSTablaTareas[iPosicion].fpu.control = 0x0360;
 stuTSSTablaTareas[iPosicion].fpu.status = 0x0000;
 stuTSSTablaTareas[iPosicion].fpu.tag = 0xFFFF;






 return (iPosicion);
}
# 443 "gdt.c"
int iFnCrearPCB( int iPosicion,
         void *pEIP,
         char *stNombre,
         unsigned int uiIndiceGDT_CS,
         unsigned int uiIndiceGDT_DS,
         unsigned int uiIndiceGDT_TSS,
         unsigned int uiPosTSS,
         unsigned int uiDirBase,
         unsigned int uiLimite,
         unsigned int uiTamanioTexto,
         unsigned int uiTamanioDatosInicializados,
         unsigned int uiTamanioStack,
         unsigned int uiBaseSs0,
         unsigned int uiIndiceGDT_SS0)
{
 int iN;
 int iJ;
 tms tmsDefault;
 itimerval itimervalDefault;

 tmsDefault.tms_utime = 0;
 tmsDefault.tms_stime = 0;
 tmsDefault.tms_cutime = 0;
 tmsDefault.tms_cstime = 0;
 itimervalDefault.it_interval.tv_sec = 0;
 itimervalDefault.it_interval.tv_usec = 0;
 itimervalDefault.it_value.tv_sec = 0;
 itimervalDefault.it_value.tv_usec = 0;

 pstuPCB[iPosicion].uiIndiceGDT_CS = uiIndiceGDT_CS;
 pstuPCB[iPosicion].uiIndiceGDT_DS = uiIndiceGDT_DS;
 pstuPCB[iPosicion].uiIndiceGDT_TSS = uiIndiceGDT_TSS;

 pstuPCB[iPosicion].vFnFuncion = pEIP;
 pstuPCB[iPosicion].iEstado = 1;
 pstuPCB[iPosicion].ulLugarTSS = uiPosTSS;
 pstuPCB[iPosicion].ulId = uiUltimoPid++;
 pstuPCB[iPosicion].ulParentId = pstuPCB[ulProcActual].ulId;
 pstuPCB[iPosicion].uiDirBase = uiDirBase;
 pstuPCB[iPosicion].uiLimite = uiLimite;
 pstuPCB[iPosicion].stuTmsTiemposProceso = tmsDefault;
 pstuPCB[iPosicion].timers[0]=itimervalDefault;
 pstuPCB[iPosicion].timers[1]=itimervalDefault;
 pstuPCB[iPosicion].timers[2]=itimervalDefault;
 pstuPCB[iPosicion].lNanosleep = 0;
 pstuPCB[iPosicion].puRestoDelNanosleep = 0;

 pstuPCB[iPosicion].uiBaseSs0 = uiBaseSs0;
    pstuPCB[iPosicion].uiIndiceGDT_SS0 = uiIndiceGDT_SS0;



    pstuPCB[iPosicion].uiTamProc = uiLimite;
 pstuPCB[iPosicion].lPidTracer = -1;

 for (iN = 0; iN < 12; iN++)
   {
     pstuPCB[iPosicion].stNombre[iN] = stNombre[iN];
   }

 pstuPCB[iPosicion].stNombre[iN] = '\0';


 pstuPCB[iPosicion].iPrioridad = 0;

 pstuPCB[iPosicion].uiLimite = uiLimite;


 for (iJ = 0; iJ < 5; iJ ++)
 {
  pstuPCB[iPosicion].memoriasAtachadas[iJ].utilizada = 0;
 }

    pstuPCB[iPosicion].uiTamanioTexto = uiTamanioTexto;
    pstuPCB[iPosicion].uiTamanioDatosInicializados=uiTamanioDatosInicializados;
    pstuPCB[iPosicion].uiTamanioStack = uiTamanioStack;


 return iPosicion;
}
# 532 "gdt.c"
int iFnInstanciarReloj( void *pEIP, char *stNombre )
{
    unsigned short int bInterrupcionesHabilitadas = 0;
    unsigned long int *puliParametroStack;
    unsigned int uiIndiceGDT_TSS;
    int iPosicion;
    int iFlags;

    __asm__ ("pushf\n pop %%eax": "=a" (iFlags):);

    if (iFlags & 0x200){
        __asm__ ("cli"::);
        bInterrupcionesHabilitadas = 1;
    }


    iPosicion = iFnBuscarPCBLibre();
    uiIndiceGDT_TSS = uiFnBuscarEntradaGDTLibre();



    if( iPosicion == -1 || !uiIndiceGDT_TSS ) {
            if(uiIndiceGDT_TSS) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_TSS-(uiIndiceGDT_TSS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_TSS)%8))); } else { iMapaGDT[ (uiIndiceGDT_TSS-(uiIndiceGDT_TSS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_TSS)%8))); } }while( 0 ); }
            return -5;
    }




    if( iPosicion != iFnCrearTSSReloj( pEIP,
                                                iPosicion,
                                                wFnGetCS(),
                                                wFnGetDS(),
                                                wFnGetSS() ) ) {





    }


    uiFnAgregarDescriptorGDT (
            (unsigned int)&stuTSSTablaTareas[iPosicion],
            sizeof( stuTSS ),
            (0x900 | 0x40),
            uiIndiceGDT_TSS);



    iFnCrearPCB( iPosicion,
             pEIP,
             stNombre,
             1,
             2,
             uiIndiceGDT_TSS,
             iPosicion,

             0x000000,

             0xffffffff,
             0,
             0,
             0,
             0,
             0
             );


    pstuPCB[iPosicion].uiTamanioOverhead = 0;



    puliParametroStack =
        (unsigned long int *)
        &( stuTSSTablaTareas[iPosicion].espacio0[4096 - 4] );
    *puliParametroStack = (unsigned long int) pstuPCB[iPosicion].ulId;

    if (bInterrupcionesHabilitadas)
      __asm__ ("sti"::);

    return iPosicion;
}







unsigned char* ucpFnMemCopy( unsigned char *ucpDestino, unsigned char *ucpOrigen, unsigned int uiTamanio )
{
 unsigned char *ucpDestinoOriginal = ucpDestino;

 while( uiTamanio-- )
  *ucpDestino++ = *ucpOrigen++;

 return ucpDestinoOriginal;
}





int iFnInstanciarIdle()
{
    iTareaNula = iFnCrearProceso("IDLE.BIN",0,0);
    return iTareaNula;
}







int iFnCrearCallGate(int iPosicion, unsigned short usOffsetBajo, unsigned short usSegmentSelector, unsigned char ucParameterCount, unsigned int uiTipo, unsigned int uiAcceso, unsigned short usOffsetAlto)
{
    unsigned short int bInterrupcionesHabilitadas = 0;
    int iFlags;
# 663 "gdt.c"
    __asm__ ("pushf\n pop %%eax": "=a" (iFlags):);

    if (iFlags & 0x200){
        __asm__ ("cli"::);
        bInterrupcionesHabilitadas = 1;
    }

    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].usLimiteBajo = usOffsetBajo;
    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].usBaseBajo = usSegmentSelector;
    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].ucBaseMedio = ucParameterCount;
    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].ucAcesso |= uiTipo;
    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].ucAcesso |= uiAcceso;
    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].bitGranularidad = 0x0;
    pstuTablaGdt->stuGdtDescriptorDescs[iPosicion].usBaseAlto = 0x0;

    if (bInterrupcionesHabilitadas)
      __asm__ ("sti"::);

    return 1;
}







void vFnAgregarListaEspera(char* stBinario, long int liTamanio)
{
   iFnCopiaCadena(stListaEspera[iCantEnEspera].stBinario,stBinario);
   stListaEspera[iCantEnEspera].liTamanio = liTamanio;
   iCantEnEspera++;
}





void vFnRecorrerListaEspera()
{
   int i;

   vFnImprimir("\nLista de programas en espera");
   vFnImprimir("\n----------------------------");
   vFnImprimir("\n\nNombre Binario                Tamanio (Bytes)");

   for(i = 0; i < iCantEnEspera; i++) vFnImprimir("\n   %s                %d",stListaEspera[i].stBinario,stListaEspera[i].liTamanio);
}
# 719 "gdt.c"
int iFnCrearProceso( char* stArchivo, int iPrivilegio, int iArgumento)
{
    unsigned short int bInterrupcionesHabilitadas = 0;
    unsigned int uiIndiceGDT_CS, uiIndiceGDT_DS, uiIndiceGDT_TSS, uiIndiceGDT_SS0;
    unsigned int uiBaseSegmento, uiBaseSS0=0;

    int iPosicion;
    int iFlags;
 int iSize;
    int i;

    unsigned int uiTamSegCodigo;
    unsigned int uiTamSegDatos;
    unsigned int uiTamStack;
 unsigned int uiEnviromentSize;
    unsigned int uiOffset;
    unsigned int uiTamHeap;
    unsigned int uiTamInicializados;
    unsigned int uiOpt;


    char* pstEnviroment;
    char stConfig[9];
 int* piVectorEnviroment;

    stuInfoEjecutable stuInfoExe;


    __asm__ ("pushf\n pop %%eax": "=a" (iFlags):);

    if (iFlags & 0x200){
        __asm__ ("cli"::);
        bInterrupcionesHabilitadas = 1;
    }


    if( iFnLeerCabeceraEjecutable(stArchivo, &stuInfoExe) == -1) {
        return -1;
    }



    uiTamSegCodigo = ( ( (( ((stuInfoExe.uiTamanioTexto) + 0x0FFF) >> 12 )) << 12 ) );
    uiTamStack = ( ( (( ((stuInfoExe.uiTamanioStack) + 0x0FFF) >> 12 )) << 12 ) );
    uiTamInicializados = stuInfoExe.uiTamanioDatosInicializados;
    uiTamHeap = 100000;
    uiTamSegDatos = ( ( (( ((uiTamSegCodigo + uiTamStack + uiTamInicializados + uiTamHeap) + 0x0FFF) >> 12 )) << 12 ) );





    uiBaseSegmento = (unsigned int) pvFnReservarParticionUsuario( uiTamSegDatos );
    if( uiBaseSegmento == -1 ) {
        vFnImprimir("\nNo hay suficiente espacio para la asignacion,\n agregando a la lista de procesos en espera...");
        vFnAgregarListaEspera(stArchivo,stArchivo);
        return -6;
    }

    uiBaseSS0 = (unsigned int) pvFnReservarParticionUsuario( 4096 );
    if( uiBaseSegmento == -1 ) {
        vFnImprimir("\nNo hay suficiente espacio para la asignacion del stack,\n agregando a la lista de procesos en espera...");
        vFnKFree( (void*)uiBaseSegmento );
        vFnAgregarListaEspera(stArchivo,stArchivo);
        return -6;
    }




    iPosicion = iFnBuscarPCBLibre();
    uiIndiceGDT_CS = uiFnBuscarEntradaGDTLibre();
    uiIndiceGDT_DS = uiFnBuscarEntradaGDTLibre();
    uiIndiceGDT_TSS = uiFnBuscarEntradaGDTLibre();
    uiIndiceGDT_SS0 = uiFnBuscarEntradaGDTLibre();





    if( iPosicion == -1 ||
        !uiIndiceGDT_CS ||!uiIndiceGDT_DS || !uiIndiceGDT_TSS ) {
            vFnKFree( (void*)uiBaseSegmento );
            vFnKFree( (void*)uiBaseSS0 );
            if(uiIndiceGDT_SS0) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_SS0-(uiIndiceGDT_SS0%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_SS0)%8))); } else { iMapaGDT[ (uiIndiceGDT_SS0-(uiIndiceGDT_SS0%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_SS0)%8))); } }while( 0 ); }
            if(uiIndiceGDT_CS ) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_CS-(uiIndiceGDT_CS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_CS)%8))); } else { iMapaGDT[ (uiIndiceGDT_CS-(uiIndiceGDT_CS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_CS)%8))); } }while( 0 ); }
            if(uiIndiceGDT_DS ) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_DS-(uiIndiceGDT_DS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_DS)%8))); } else { iMapaGDT[ (uiIndiceGDT_DS-(uiIndiceGDT_DS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_DS)%8))); } }while( 0 ); }
            if(uiIndiceGDT_TSS) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_TSS-(uiIndiceGDT_TSS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_TSS)%8))); } else { iMapaGDT[ (uiIndiceGDT_TSS-(uiIndiceGDT_TSS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_TSS)%8))); } }while( 0 ); }
            return -5;
    }




    uiOpt = (0x1800 | 0x200 | 0x40 | 0x80);
    if (iPrivilegio == 3) uiOpt |= 0x6000;
    if (iPrivilegio == 2) uiOpt |= 0x4000;
    if (iPrivilegio == 1) uiOpt |= 0x2000;

    uiFnAgregarDescriptorGDT (
            uiBaseSegmento,
            ( ((uiTamSegCodigo) + 0x0FFF) >> 12 ) - 1,
            uiOpt,
            uiIndiceGDT_CS);




    uiOpt = (0x1000 | 0x200 | 0x40 | 0x80);
    if (iPrivilegio == 3) uiOpt |= 0x6000;
    if (iPrivilegio == 2) uiOpt |= 0x4000;
    if (iPrivilegio == 1) uiOpt |= 0x2000;

    uiFnAgregarDescriptorGDT (
            uiBaseSegmento,
            ( ((uiTamSegDatos) + 0x0FFF) >> 12 ) - 1,
            uiOpt,
            uiIndiceGDT_DS);



    uiFnAgregarDescriptorGDT (
 uiBaseSS0,
 4096 - 1,
 (0x1000 | 0x200 | 0x40 | 0x80 ),
 uiIndiceGDT_SS0);




    vFnLog("\nCopiando el codigo del proceso \"%s\" de 0x%x a 0x%x, ocupa %d "
            "bytes", stuInfoExe.stNombre, stuInfoExe.pvPuntoCarga,
            uiBaseSegmento, stuInfoExe.uiTamanioTexto);
    ucpFnCopiarMemoria(
        (unsigned char*)uiBaseSegmento,
        (unsigned char*)stuInfoExe.pvPuntoCarga,
        stuInfoExe.uiTamanioTexto );
# 864 "gdt.c"
    pstEnviroment = pstFnObtenerEnviroment();
    uiEnviromentSize = 0;
    while(pstEnviroment[uiEnviromentSize] != '\0')
      {
     if(pstEnviroment[uiEnviromentSize] == '\n')pstEnviroment[uiEnviromentSize] = '\0';
     uiEnviromentSize++;
      }

    uiOffset = uiEnviromentSize;


       for(i=0; i < uiOffset; i++) *(unsigned char*)(uiBaseSegmento + 0x9000 - uiOffset + i ) = pstEnviroment[i];



     uiOffset = uiOffset + sizeof(int);
  *(int*)(uiBaseSegmento + 0x9000 - uiOffset ) = 0 ;


          for( i = uiEnviromentSize -1 ; i > 0; i--)
      {
      if(pstEnviroment[i] == '\0')
        {
        uiOffset = uiOffset + sizeof(int);
     *(int*)(uiBaseSegmento + 0x9000 - uiOffset ) = 0x9000 - uiEnviromentSize + i +1 ;
     }
   }

    uiOffset = uiOffset + sizeof(int);
       piVectorEnviroment = 0x9000 - uiOffset;
    *(int*)(uiBaseSegmento + 0x9000 - uiOffset) = 0x9000 - uiEnviromentSize;
    uiOffset = uiOffset + 2*sizeof(int);
# 905 "gdt.c"
    iSize = 0;
    while(stuInfoExe.stNombre[iSize] != '\0') iSize++;
    iSize = iSize - 3;
    uiOffset = uiOffset + iSize;
    for(i=0; i < iSize; i++) *(unsigned char*)(uiBaseSegmento + 0x9000 - uiOffset + i + sizeof(int) ) = stuInfoExe.stNombre[i];
    *(unsigned char*)(uiBaseSegmento + 0x9000 - uiOffset + iSize + sizeof(int) ) = '\0';


    uiOffset = uiOffset + sizeof(int);
    *(int*)(uiBaseSegmento + 0x9000 - uiOffset + sizeof(int) ) = 0;

    uiOffset = uiOffset + sizeof(int);
    *(int*)(uiBaseSegmento + 0x9000 - uiOffset + sizeof(int) ) = 0x9000 - uiOffset + 3*sizeof(int);




    uiOffset = uiOffset + sizeof(int);
    *(int*)(uiBaseSegmento + 0x9000 - uiOffset + sizeof(int) ) = piVectorEnviroment;

    uiOffset = uiOffset + sizeof(int);
    *(int*)(uiBaseSegmento + 0x9000 - uiOffset + sizeof(int) ) = 0x9000 - uiOffset + 3*sizeof(int);

    uiOffset = uiOffset + sizeof(int);
    *(int*)(uiBaseSegmento + 0x9000 - uiOffset + sizeof(int) ) = 1;


          vFnKFree(pstEnviroment);







    if( iPosicion != iFnCrearTSS( 0x0,
                                    (void*)0x9000,
                                    iPosicion,
                                    uiOffset,
                                    uiIndiceGDT_CS * 8,
                                    uiIndiceGDT_DS * 8,
                                    uiIndiceGDT_DS * 8,
                                    uiIndiceGDT_SS0 * 8,
                                    iPrivilegio ) ) {





    }


    uiFnAgregarDescriptorGDT (
            (unsigned int)&stuTSSTablaTareas[iPosicion],
            sizeof( stuTSS ),
            (0x900 | 0x40),
            uiIndiceGDT_TSS);



    iFnCrearPCB( iPosicion,
             0x0,
             stuInfoExe.stNombre,
             uiIndiceGDT_CS,
             uiIndiceGDT_DS,
             uiIndiceGDT_TSS,
             iPosicion,
             uiBaseSegmento,
             uiTamSegDatos,
             uiTamSegCodigo,
             uiTamInicializados,
             uiTamStack,
             uiBaseSS0,
             uiIndiceGDT_SS0
             );




    ucpFnCopiarMemoria((unsigned char*)&pstuPCB[iPosicion].stuCabeceraELF,(unsigned char*)ucLecturaTemporalELF, 0x80);
# 994 "gdt.c"
    pstuPCB[iPosicion].uiTamanioOverhead =
                                    uiTamSegCodigo - stuInfoExe.uiTamanioTexto;
    pstuPCB[iPosicion].uiEsperaTeclado = 0;
# 1008 "gdt.c"
    if (bInterrupcionesHabilitadas)
      __asm__ ("sti"::);

    return iPosicion;
}







char* pstFnObtenerEnviroment()
{
 unsigned int uiSize;
 unsigned int i;
 char *pstEnviroment;





 char stEnviromentProvisorio[]="PorcentajePartFija=10\nTamanioHeapUsuario=100000\nTipoPartFija=FIJO\nModoMemUser=VARIABLE\nModoShell=PASIVO\nOutputProceso=NORMAL";
# 1042 "gdt.c"
 uiSize = 0;
 while (stEnviromentProvisorio[uiSize] != '\0') uiSize++;

 pstEnviroment = (char*)pvFnReservarParticionKernel(uiSize*sizeof(char));

 for(i = 0; i <= uiSize; i++) pstEnviroment[i] = stEnviromentProvisorio[i];

 return pstEnviroment;
}
# 1061 "gdt.c"
int iFnRedimensionarProceso(unsigned long ulPid, unsigned long ulBrk) {
    unsigned long ulDirBaseNueva;
    stuPCB* pPCB;

    pPCB = &pstuPCB[ iFnBuscaPosicionProc(ulPid) ];



    ulBrk = ( ( (( ((ulBrk) + 0x0FFF) >> 12 )) << 12 ) );






    if( ulBrk <= (pPCB->uiTamanioTexto +
                  pPCB->uiTamanioDatosInicializados +
                  pPCB->uiTamanioStack) ||
        ulBrk <= ulFnMaxDirShmProc(ulPid) ) {
        vFnLog("\niFnRedimensionarProceso: No se puede redimensionar proceso, "
                "BRK invalido (valor muy bajo)");
        return -1;
    }




    if( ulBrk >= 0x4000000) {
        vFnLog("\niFnRedimensionarProceso: No se puede redimensionar proceso, "
                "BRK invalido (valor mayor al permitido por el sistema)");
        return -1;
    }


    ulDirBaseNueva = (unsigned long) pvFnRedimensionarSegmento( (void *)pPCB->uiDirBase, ulBrk);



    if(ulDirBaseNueva < 0) {
        vFnLog("\niFnRedimensionarProceso: No se pudo redimensionar proceso");
        return -1;
    }


    pPCB->uiDirBase = ulDirBaseNueva;
    pPCB->uiLimite = ulBrk;
    pPCB->uiTamProc = ulBrk;


    uiFnSetearBaseLimiteDescriptor(pPCB->uiIndiceGDT_CS, ulDirBaseNueva,
            ( ((ulBrk) + 0x0FFF) >> 12 ) - 1 );
    uiFnSetearBaseLimiteDescriptor(pPCB->uiIndiceGDT_DS, ulDirBaseNueva,
            ( ((ulBrk) + 0x0FFF) >> 12 ) - 1 );

    vFnLog("\niFnRedimensionarProceso: Se redimensiono Proceso PID=%d", ulPid);

    return 0;
}







int iFnDuplicarProceso( unsigned int uiProcPadre ){
 unsigned int uiIndiceGDT_CS,
       uiIndiceGDT_DS,
       uiIndiceGDT_TSS,
       uiIndiceGDT_SS0,
       uiStackUsuario,
       uiComienzoStackKernel,
       uiBaseSegmento,
       uiBaseSS0=0;

    unsigned int uiTamSegCodigo;
    unsigned int uiTamSegDatos;
    unsigned int uiTamStack;
    unsigned int uiTamInicializados;
    unsigned int uiOpt;

    unsigned int *puiPuntero;

    uiTamSegCodigo = pstuPCB[uiProcPadre].uiTamanioTexto;

    uiTamHeap = uiTamHeap;
    uiTamSegDatos = ( ( (( ((pstuPCB[uiProcPadre].uiTamanioTexto+pstuPCB[uiProcPadre].uiTamanioStack+pstuPCB[uiProcPadre].uiTamanioDatosInicializados + uiTamHeap) + 0x0FFF) >> 12 )) << 12 ) );
    uiTamStack = pstuPCB[uiProcPadre].uiTamanioStack;
    uiTamInicializados = pstuPCB[uiProcPadre].uiTamanioDatosInicializados;

 int iPosicion = 0;






     vFnLog("\nComenzando FORK");

 iPosicion = iFnBuscarPCBLibre();

uiBaseSegmento = (unsigned int) pvFnReservarParticionUsuario( uiTamSegDatos );
    if( uiBaseSegmento == -1 ) {
        vFnLog("\nfork(): No hay particion libre suficiente para fork.");
        return -1;
    }
   vFnLog("\nBase segmento: %d",uiBaseSegmento);

    uiBaseSS0 = (unsigned int) pvFnReservarParticionUsuario( 4096 );
    if( uiBaseSS0 == -1 ) {
        vFnImprimir("\nNo hay suficiente espacio para la asignacion del stack,\n agregando a la lista de procesos en espera...");
        vFnKFree( (void*)uiBaseSegmento );
        return -1;
    }



 uiIndiceGDT_CS = uiFnBuscarEntradaGDTLibre();
 uiIndiceGDT_DS = uiFnBuscarEntradaGDTLibre();
 uiIndiceGDT_TSS = uiFnBuscarEntradaGDTLibre();
 uiIndiceGDT_SS0 = uiFnBuscarEntradaGDTLibre();




    if( iPosicion == -1 ||
        !uiIndiceGDT_CS ||!uiIndiceGDT_DS || !uiIndiceGDT_TSS ) {
            vFnKFree( (void*)uiBaseSegmento );
            if(uiIndiceGDT_SS0) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_SS0-(uiIndiceGDT_SS0%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_SS0)%8))); } else { iMapaGDT[ (uiIndiceGDT_SS0-(uiIndiceGDT_SS0%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_SS0)%8))); } }while( 0 ); }
            if(uiIndiceGDT_CS ) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_CS-(uiIndiceGDT_CS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_CS)%8))); } else { iMapaGDT[ (uiIndiceGDT_CS-(uiIndiceGDT_CS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_CS)%8))); } }while( 0 ); }
            if(uiIndiceGDT_DS ) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_DS-(uiIndiceGDT_DS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_DS)%8))); } else { iMapaGDT[ (uiIndiceGDT_DS-(uiIndiceGDT_DS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_DS)%8))); } }while( 0 ); }
            if(uiIndiceGDT_TSS) { do{ if( 0 ){ iMapaGDT[ (uiIndiceGDT_TSS-(uiIndiceGDT_TSS%8)) / 8 ] |= (1 << (7-((uiIndiceGDT_TSS)%8))); } else { iMapaGDT[ (uiIndiceGDT_TSS-(uiIndiceGDT_TSS%8)) / 8 ] &= ~(1 << (7-((uiIndiceGDT_TSS)%8))); } }while( 0 ); }
            return -5;
    }

 vFnLog( "\n fork(): iFnBuscarPCBLibre: %d", iPosicion );
    vFnLog( "\n fork(): Inicio nuevo segmento: 0x%x", uiBaseSegmento );
     vFnLog( "\n fork(): uiFnBuscarEntradaGDTLibre(SS0): %d, 0x%x",
            uiIndiceGDT_SS0, uiIndiceGDT_SS0 * 8 );
    vFnLog( "\n fork(): uiFnBuscarEntradaGDTLibre(CS): %d, 0x%x",
            uiIndiceGDT_CS, uiIndiceGDT_CS * 8 );
    vFnLog( "\n fork(): uiFnBuscarEntradaGDTLibre(DS): %d, 0x%x",
            uiIndiceGDT_DS, uiIndiceGDT_DS * 8 );
    vFnLog( "\n fork(): uiFnBuscarEntradaGDTLibre(TSS): %d, 0x%x",
            uiIndiceGDT_TSS, uiIndiceGDT_TSS * 8 );




 ucpFnCopiarMemoria( (unsigned char*) &pstuTablaGdt->stuGdtDescriptorDescs[uiIndiceGDT_CS],
  (unsigned char*) &pstuTablaGdt->stuGdtDescriptorDescs[stuTSSTablaTareas[uiProcPadre].cs / 8],
  sizeof( stuGDTDescriptor ) );







    uiOpt = (0x1800 | 0x200 | 0x40 | 0x80 | 0x6000);

    uiFnAgregarDescriptorGDT (
            uiBaseSegmento,
            ( ((uiTamSegCodigo) + 0x0FFF) >> 12 ) - 1,
            uiOpt,
            uiIndiceGDT_CS);






 ucpFnCopiarMemoria( (unsigned char*) &pstuTablaGdt->stuGdtDescriptorDescs[uiIndiceGDT_DS],
  (unsigned char*) &pstuTablaGdt->stuGdtDescriptorDescs[stuTSSTablaTareas[uiProcPadre].ds / 8],
  sizeof( stuGDTDescriptor ) );



    uiOpt = (0x1000 | 0x200 | 0x40 | 0x80 | 0x6000);

    uiFnAgregarDescriptorGDT (
            uiBaseSegmento,
            ( ((uiTamSegDatos) + 0x0FFF) >> 12 ) - 1,
            uiOpt,
            uiIndiceGDT_DS);



 ucpFnCopiarMemoria( (unsigned char*) &pstuTablaGdt->stuGdtDescriptorDescs[uiIndiceGDT_SS0],
  (unsigned char*) &pstuTablaGdt->stuGdtDescriptorDescs[stuTSSTablaTareas[uiProcPadre].ss0 / 8],
  sizeof( stuGDTDescriptor ) );


    uiFnAgregarDescriptorGDT (
 uiBaseSS0,
 ( ((4096 - 1) + 0x0FFF) >> 12 ),
 (0x1000 | 0x200 | 0x40 | 0x80 ),
 uiIndiceGDT_SS0);




 ucpFnCopiarMemoria( (unsigned char*)uiBaseSegmento,
  (unsigned char*)pstuPCB[uiProcPadre].uiDirBase,
                        uiTamSegDatos );


 ucpFnCopiarMemoria( (unsigned char*)uiBaseSS0,
  (unsigned char*)pstuPCB[uiProcPadre].uiBaseSs0,
                        4096 );
# 1279 "gdt.c"
  stuTSSTablaTareas[iPosicion].trapbit = 0;
 stuTSSTablaTareas[iPosicion].uIOMapeoBase = sizeof (stuTSS);



     stuTSSTablaTareas[iPosicion].cs = (uiIndiceGDT_CS * 8) | 0x03 ;
     stuTSSTablaTareas[iPosicion].ds = (uiIndiceGDT_DS * 8) | 0x03;
  stuTSSTablaTareas[iPosicion].ss = (uiIndiceGDT_DS * 8) | 0x03;
  stuTSSTablaTareas[iPosicion].es = (uiIndiceGDT_DS * 8) | 0x03;
  stuTSSTablaTareas[iPosicion].fs = (uiIndiceGDT_DS * 8) | 0x03 ;
  stuTSSTablaTareas[iPosicion].gs = (uiIndiceGDT_DS * 8) | 0x03;
  stuTSSTablaTareas[iPosicion].ss0 = (uiIndiceGDT_SS0 * 8);
    stuTSSTablaTareas[iPosicion].ss1 = 0;
  stuTSSTablaTareas[iPosicion].ss2 = 0;

  stuTSSTablaTareas[iPosicion].esp0 = (unsigned int) (4096 - 0x1);
 stuTSSTablaTareas[iPosicion].esp1 = (unsigned int) (4096 - 0x1);
 stuTSSTablaTareas[iPosicion].esp2 = (unsigned int) (4096 - 0x1);






 uiComienzoStackKernel = uiKernelStack - 0x08 - 0x100 * ((pstuPCB[uiProcPadre].uiIndiceGDT_TSS * 8)-0x20);
 stuTSSTablaTareas[iPosicion].esp = *(unsigned int*)(uiComienzoStackKernel-0x08);
 uiStackUsuario = stuTSSTablaTareas[iPosicion].esp + pstuPCB[uiProcPadre].uiBaseSs0;





 stuTSSTablaTareas[iPosicion].ebp = *(unsigned int*)(uiComienzoStackKernel-0x0c);
 stuTSSTablaTareas[iPosicion].edx = *(unsigned int*)(uiComienzoStackKernel-0x10);
 stuTSSTablaTareas[iPosicion].ecx = *(unsigned int*)(uiComienzoStackKernel-0x14);
  stuTSSTablaTareas[iPosicion].ebx = *(unsigned int*)(uiComienzoStackKernel-0x18);
 stuTSSTablaTareas[iPosicion].eax = 0;
# 1328 "gdt.c"
   stuTSSTablaTareas[iPosicion].edi = *(unsigned int*)(uiStackUsuario+0x04);
   stuTSSTablaTareas[iPosicion].esi = *(unsigned int*)(uiStackUsuario+0x08);
   stuTSSTablaTareas[iPosicion].eip = *(unsigned int*)(uiStackUsuario+0x1C);

    stuTSSTablaTareas[iPosicion].uiEBandera = 0x3202L;
# 1344 "gdt.c"
 stuTSSTablaTareas[iPosicion].ldt = stuTSSTablaTareas[uiProcPadre].ldt;



 uiFnAgregarDescriptorGDT ((unsigned int)
                    &stuTSSTablaTareas[iPosicion], sizeof( stuTSS ),
                    (0x900 + 0x40), uiIndiceGDT_TSS);
# 1378 "gdt.c"
 iFnCrearPCB( iPosicion,
       0,
       pstuPCB[uiProcPadre].stNombre,
       uiIndiceGDT_CS,
       uiIndiceGDT_DS,
       uiIndiceGDT_TSS,
       iPosicion,
       uiBaseSegmento,
             uiTamSegDatos,
             uiTamSegCodigo,
             uiTamInicializados,
             uiTamStack,
             uiBaseSS0,
             uiIndiceGDT_SS0
             );


    ++pstuPCB[uiProcPadre].lNHijos;




    pstuPCB[iPosicion].ulParentId = pstuPCB[uiProcPadre].ulId;




    return iPosicion;
}
# 1415 "gdt.c"
int iFnReemplazarProceso( unsigned long ulPid, char * stArchivo, unsigned int uiOffset ) {
    unsigned int uiESPOriginal,
             uiStackUsuario,
             uiComienzoStackKernel,
             uiIndiceGDT_DS,
             uiOpt;

    unsigned int uiBaseSegmento;
    unsigned int uiTamSegCodigo;
    unsigned int uiTamSegDatos;
    unsigned int uiTamStack;
    unsigned int uiTamInicializados;
    unsigned int uiTamHeap;

    int iPosicion;
    int iFlags;
    int i;

    stuInfoEjecutable stuInfoExe;



    stuPCB* pPCB;
# 1446 "gdt.c"
    if( iFnLeerCabeceraEjecutable(stArchivo, &stuInfoExe) == -1) {
        return -1;
    }



    uiTamSegCodigo = ( ( (( ((stuInfoExe.uiTamanioTexto) + 0x0FFF) >> 12 )) << 12 ) );
    uiTamStack = ( ( (( ((stuInfoExe.uiTamanioStack) + 0x0FFF) >> 12 )) << 12 ) );
    uiTamInicializados = ( ( (( ((stuInfoExe.uiTamanioDatosInicializados) + 0x0FFF) >> 12 )) << 12 ) );
    uiTamHeap = uiTamHeap;
    uiTamSegDatos = ( ( (( ((uiTamSegCodigo + uiTamStack + uiTamInicializados + uiTamHeap) + 0x0FFF) >> 12 )) << 12 ) );
# 1472 "gdt.c"
    uiBaseSegmento = (unsigned int) pvFnReservarParticionUsuario( uiTamSegDatos );
    if( uiBaseSegmento == -1 ) {
        vFnLog("\nNo hay suficiente espacio para la asignacion");
        return -1;
    }





    pPCB = &pstuPCB[ iFnBuscaPosicionProc(ulPid) ];




    uiFnSetearBaseLimiteDescriptor(pPCB->uiIndiceGDT_CS, uiBaseSegmento,
            ( ((uiTamSegCodigo) + 0x0FFF) >> 12 ) - 1 );
    uiFnSetearBaseLimiteDescriptor(pPCB->uiIndiceGDT_DS, uiBaseSegmento,
            ( ((uiTamSegDatos) + 0x0FFF) >> 12 ) - 1 );



    vFnLog("\niFnReemplazarProceso: Copiando el codigo del proceso \"%s\" de "
            "0x%x a 0x%x, ocupa %d bytes", stuInfoExe.stNombre,
            stuInfoExe.pvPuntoCarga, uiBaseSegmento, stuInfoExe.uiTamanioTexto);
    ucpFnCopiarMemoria(
        (unsigned char*)uiBaseSegmento,
        (unsigned char*)stuInfoExe.pvPuntoCarga,
        stuInfoExe.uiTamanioTexto );



    uiOpt = (0x1000 | 0x200 | 0x40 | 0x80 | 0x6000);

    uiIndiceGDT_DS = pPCB->uiIndiceGDT_DS;
# 1532 "gdt.c"
 uiComienzoStackKernel = uiKernelStack - 0x08 - 0x100 * ((pstuPCB[iFnBuscaPosicionProc(ulPid)].uiIndiceGDT_TSS * 8)-0x20);

 uiStackUsuario = *(int*)(uiComienzoStackKernel - 0x08) + pstuPCB[iFnBuscaPosicionProc(ulPid)].uiBaseSs0;
# 1543 "gdt.c"
 *(unsigned int*)(uiComienzoStackKernel-0x0c) = 0x9000 - uiOffset;
 *(unsigned int*)(uiComienzoStackKernel-0x10) = 0x0;
 *(unsigned int*)(uiComienzoStackKernel-0x14) = 0x0;
  *(unsigned int*)(uiComienzoStackKernel-0x18) = 0x0;





   *(unsigned int*)(uiStackUsuario-0x04) = 0x3202L;
   *(unsigned int*)(uiStackUsuario+0x00) = 0x0;
   *(unsigned int*)(uiStackUsuario+0x04) = 0x0;
   *(unsigned int*)(uiStackUsuario+0x1C) = 0x0;
   *(unsigned int*)(uiStackUsuario+0x28) = 0x9000 - uiOffset;
# 1568 "gdt.c"
    pPCB->vFnFuncion = 0x00;
    pPCB->uiTamProc = uiTamSegDatos;
    pPCB->uiDirBase = uiBaseSegmento;
    pPCB->uiLimite = uiTamSegDatos;
    pPCB->uiTamanioTexto = uiTamSegCodigo;
    pPCB->uiTamanioDatosInicializados = uiTamInicializados;
    pPCB->uiTamanioStack = uiTamStack;





    pPCB->uiTamanioOverhead =
                                    uiTamSegCodigo - stuInfoExe.uiTamanioTexto;
    pPCB->uiEsperaTeclado = 0;

    ucpFnCopiarMemoria((unsigned char*)&pPCB->stuCabeceraELF,(unsigned char*)ucLecturaTemporalELF, 0x80);




    iFnShmDtAllProc( ulPid );







    pPCB->uiIndiceGDT_DS = uiIndiceGDT_DS;

    return (int) ulPid;
}







int iFnEliminarProceso( unsigned int uiProceso ){
    int iPCBPadre;

    vFnLog( "\niFnEliminarProceso(): Liberando el segmento base %x (%d bytes)",
             pstuPCB[ uiProceso ].uiDirBase, pstuPCB[ uiProceso ].uiLimite);

    vFnLiberarParticion( (void *)pstuPCB[ uiProceso ].uiDirBase);
    vFnLiberarParticion( (void *)pstuPCB[ uiProceso ].uiBaseSs0);

    vFnLog( "\n iFnEliminarProceso(): Liberando entradas %d, %d y %d de la GDT, del pid: %d",
             pstuPCB[ uiProceso ].uiIndiceGDT_CS,
             pstuPCB[ uiProceso ].uiIndiceGDT_DS,
             pstuPCB[ uiProceso ].uiIndiceGDT_TSS,
             uiProceso );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_CS-(pstuPCB[ uiProceso ].uiIndiceGDT_CS%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_CS)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_CS-(pstuPCB[ uiProceso ].uiIndiceGDT_CS%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_CS)%8))); } }while( 0 );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_DS-(pstuPCB[ uiProceso ].uiIndiceGDT_DS%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_DS)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_DS-(pstuPCB[ uiProceso ].uiIndiceGDT_DS%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_DS)%8))); } }while( 0 );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_TSS-(pstuPCB[ uiProceso ].uiIndiceGDT_TSS%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_TSS)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_TSS-(pstuPCB[ uiProceso ].uiIndiceGDT_TSS%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_TSS)%8))); } }while( 0 );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_SS0-(pstuPCB[ uiProceso ].uiIndiceGDT_SS0%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_SS0)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_SS0-(pstuPCB[ uiProceso ].uiIndiceGDT_SS0%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_SS0)%8))); } }while( 0 );



    vFnLog( "\n iFnEliminarProceso(): Liberando entradas %d, %d y %d de la GDT, del pid: %d",
             pstuPCB[ uiProceso ].uiIndiceGDT_CS,
             pstuPCB[ uiProceso ].uiIndiceGDT_DS,
             pstuPCB[ uiProceso ].uiIndiceGDT_TSS,
             uiProceso );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_CS-(pstuPCB[ uiProceso ].uiIndiceGDT_CS%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_CS)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_CS-(pstuPCB[ uiProceso ].uiIndiceGDT_CS%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_CS)%8))); } }while( 0 );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_DS-(pstuPCB[ uiProceso ].uiIndiceGDT_DS%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_DS)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_DS-(pstuPCB[ uiProceso ].uiIndiceGDT_DS%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_DS)%8))); } }while( 0 );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_TSS-(pstuPCB[ uiProceso ].uiIndiceGDT_TSS%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_TSS)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_TSS-(pstuPCB[ uiProceso ].uiIndiceGDT_TSS%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_TSS)%8))); } }while( 0 );
    do{ if( 0 ){ iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_SS0-(pstuPCB[ uiProceso ].uiIndiceGDT_SS0%8)) / 8 ] |= (1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_SS0)%8))); } else { iMapaGDT[ (pstuPCB[ uiProceso ].uiIndiceGDT_SS0-(pstuPCB[ uiProceso ].uiIndiceGDT_SS0%8)) / 8 ] &= ~(1 << (7-((pstuPCB[ uiProceso ].uiIndiceGDT_SS0)%8))); } }while( 0 );


    iPCBPadre = iFnBuscaPosicionProc( pstuPCB[ uiProceso ].ulParentId );
    if (pstuPCB[iPCBPadre].iEstado == 2) {
        pstuPCB[iPCBPadre].iEstado = 1;
    }


    iFnShmDtAllProc( pstuPCB[ uiProceso ].ulId );



    vFnLog( "\n iFnEliminarProceso(): Eliminando PCB %d (PID %d)", uiProceso,
             pstuPCB[ uiProceso ].ulId );
    pstuPCB[ uiProceso ].iEstado = 4;


    return uiProceso;
}







int iFnLeerCabeceraEjecutable(char* stArchivo, stuInfoEjecutable* pstuInfo) {

    int i;
    stEntradaLS *pstEntLs;
    stDirectorio *pstDirBusqueda;
    stuHeaderELF *stELF;

    if (iFnObtenerDirectorio("/mnt/usr", &pstDirBusqueda) < 0) {
        vFnImprimir("\nSodium Dice: Error! Directorio /mnt/usr no existe");
        return -1;
    }
    if( iFnBuscarArchivo(pstDirBusqueda, stArchivo, &pstEntLs) < 0) {
        vFnImprimir("\nSodium Dice: Error! El archivo %s no existe", stArchivo);
        return -1;
    }


    pstuInfo->pvPuntoCarga = (void*)( (pstEntLs->wSeg) * 16 + (pstEntLs->wOff) );



     ucpFnCopiarMemoria((unsigned char*)ucLecturaTemporalELF,(unsigned char*)pstuInfo->pvPuntoCarga, 0x80);


    pstuInfo->pvPuntoCarga = pstuInfo->pvPuntoCarga + 0x80;

    stELF = &ucLecturaTemporalELF;

    pstuInfo->uiTamanioTexto = stELF->SHeaderData.size;
    pstuInfo->uiTamanioDatosInicializados = 0;
    pstuInfo->uiTamanioStack = 0x0F000;

    for (i = 0; i < 11; i++) {
        pstuInfo->stNombre[i] = pstEntLs->strNombreArchivo[i];
    }
    pstuInfo->stNombre[i] = '\0';

    return 0;
}






int iFnChequearEjecutable(char* stArchivo) {
# 1718 "gdt.c"
    int i;
    stEntradaLS *pstEntLs;
    stDirectorio *pstDirBusqueda;


    if (iFnObtenerDirectorio("/mnt/usr", &pstDirBusqueda) < 0) {
        vFnImprimir("\nSodium Dice: Error! Directorio /mnt/usr no existe");
        return 0;
    }
    if( iFnBuscarArchivo(pstDirBusqueda, stArchivo, &pstEntLs) < 0) {
        return 0;
    }


    return 1;
}




int iFnClonarProceso()
{
    return 0;
}






int iFnInstanciarProceso(char *stProceso, int iPrivilegio, int iArgumento)
{
    return iFnCrearProceso(stProceso,iPrivilegio,iArgumento);
}
